# -*- coding: UTF-8 -*-
import copy

from openpyxl import Workbook
from openpyxl import load_workbook
from openpyxl.utils import get_column_interval
import re
import time
import os
from tqdm import tqdm
# import cProfile
# from pyinstrument import Profiler
from CommonData import CommonData as cd

class MyTxtToExcel:
    def __init__(self):
        tqdm.write("初始化成功")
        self.data_file = ""  # 数据集所在文件位置
        self.comb_data_file = ""
        self.output = ""
        self.replace_file = ""
        self.true_value_flag = ""  # 控制是否要乘以小数
        self.lose_value_flag = ""  # 控制是否缺失的值为用户自定义的
        self.replace_flag = ""
        self.lose_value = ""  # 默认为缺失
        self.lose_file = ""
        self.true_value = 1
        self.sheet_child = []  # 要处理的项目数量,（需要建立的sheet数目）
        self.process_bar_value = 0
        self.separate_value = ""
        self.name_types = {
            'PRS': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '平均本站气压', '日最高本站气压', '日最低本站气压', '平均本站气压质量控制码','日最高本站气压质量控制码', '日最低本站气压质量控制码'],
            'TEM': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '平均气温', '日最高气温', '日最低气温', '平均气温控制码', '日最高气温质量控制码','日最低气温质量控制码'],
            'RHU': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '平均相对湿度', '最小相对湿度(仅自己)', '平均相对湿度质量控制码', '最小相对湿度质量控制码'],
            'PRE': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '20-8时降水量', '8-20时降水量', '20-20时累计降水量', '20-8时降水量质量控制码','8-20时累计降水量质量控制码', '20-20时降水量质量控制码'],
            'EVP': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '小型蒸发量', '大型蒸发量', '小型蒸发量质量控制码', '大型蒸发量质量控制码'],
            'WIN': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '平均风速', '最大风速', '最大风速的风向', '极大风速', '极大风速的风向','平均风速质量控制码', '最大风速质量控制码', '最大风速的风向质量控制码', '极大风速质量控制码', '极大风速的风向质量控制码'],
            'SSD': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '日照时数', '日照时数质量控制码'],
            'GST_0CM': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '平均地表气温', '日最高地表气温', '日最低地表气温', '平均地表气温质量控制码','日最高地表气温质量控制码', '日最低地表气温质量控制码'],
            'QRA': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日','太阳总辐射日曝辐量'],
            '组合气象因子': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '20-20时降水量', '极大风速', '极大风速的风向', '平均本站气压', '平均风速', '平均气温', '平均水汽压','平均相对湿度','日照时数', '日最低本站气压', '日最低气温', '日最高本站气压', '日最高气温', '最大风速', '最大风速的风向', '最小相对湿度'],
            'VAP': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '平均水汽压', '日最高水汽压', '日最低水汽压', '平均水汽压质量控制码','日最高水汽压质量控制码', '日最低水汽压质量控制码'],
            'GSS': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '日积雪深度', '日雪压', '日积雪深度质量控制码', '日雪压质量控制码'],
            'ICE': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '南北电线结冰类型', '南北电线结冰重量', '南北电线结冰直径', '南北电线结冰厚度','东西电线结冰类型', '东西电线结冰重量','东西电线结冰直径', '东西电线结冰厚度', '出现结冰时气温', '出现结冰时风向', '出现结冰时风速', '南北电线结冰类型质量控制码', '南北电线结冰重量质量控制码','南北电线结冰直径质量控制码','南北电线结冰厚度质量控制码', '东西电线结冰类型质量控制码', '东西电线结冰重量质量控制码', '东西电线结冰直径质量控制码', '东西电线结冰厚度质量控制码', '出现结冰时气温质量控制码','出现结冰时风向质量控制码', '出现结冰时风速质量控制码'],
            'GST': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '平均5cm地温', '平均10cm地温', '平均15cm地温', '平均20cm地温', '平均40cm地温', '平均80cm地温', '平均160cm地温', '平均320cm地温', '平均5cm地温质量控制码', '平均10cm地温质量控制码', '平均15cm地温质量控制码', '平均20cm地温质量控制码', '平均40cm地温质量控制码','平均80cm地温质量控制码', '平均160cm地温质量控制码', '平均320cm地温质量控制码'],
            'GLT': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '日平均草面温度', '日最高草面温度', '日最低草面温度', '日平均草面温度质量控制码', '日最高草面温度质量控制码', '日最低草面温度质量控制码'],
            'FRS': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '第一冻土层上界值', '第一冻土层下界值', '第二冻土层上界值', '第二冻土层下界值','第一冻土层上界值质量控制码', '第一冻土层下界值质量控制码', '第二冻土层上界值质量控制码', '第二冻土层下界值质量控制码'],
            'CLO': ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月', '日', '平均总云量', '平均低云量', '平均总云量质量控制码', '平均低云量控制码'],

        }
        self.coefficients = {
            'PRS': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 0.1, 1, 1, 1],
            'TEM': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 0.1, 1, 1, 1],
            'RHU': [1, 1, 1, 0.1, 1, 1, 1, 1, 1, 1, 1],
            'PRE': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 0.1, 1, 1, 1],
            'EVP': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 1, 1],
            'WIN': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 1, 0.1, 1, 1, 1, 1, 1, 1],
            'SSD': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 1],
            'GST_0CM': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 0.1, 1, 1, 1],
            'QRA': [1, 1, 1, 0.1, 1, 1, 1, 0.01, 0.1],
            '组合气象因子': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 1, 0, 1, 0.1, 0.1, 1, 1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 1, 1, 1, 1],
            'VAP': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 0.1, 1, 1, 1],
            'CLO': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 1, 1],
            'GSS': [1, 1, 1, 0.1, 1, 1, 1, 1, 0.1, 1, 1],
            'ICE': [1, 1, 1, 0.1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0.1, 1, 0.1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
            'GST': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 1, 1, 1, 1, 1, 1, 1, 1],
            'FRS': [1, 1, 1, 0.1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
            'GLT': [1, 1, 1, 0.1, 1, 1, 1, 0.1, 0.1, 0.1, 1, 1, 1],
        }

    def get_abnormal(fun):
        def abnormal(self, *args, **kwargs):
            try:
                return fun(self, *args, **kwargs)
            except Exception as e:
                print("异常信息:{},异常方法:{}".format(e, fun.__name__))

        return abnormal  # 没有返回值


    #@get_abnormal
    def putInfos(self, data_input, output, true_value_flag, true_value, lose_value_flag, lose_value, separate_value, sheet, replace_type_name, replace_flag, replace_file, dist_num, province, site_num, long, lat, alt,select_type_year, select_type_month,specil, specil_select):
        self.data_file = data_input
        self.comb_data_file = data_input
        self.output = output
        self.true_value_flag = true_value_flag  # 控制是否要乘以小数
        self.lose_value_flag = lose_value_flag  # 控制是否缺失的值为用户自定义的
        self.lose_value = lose_value  # 默认为缺失
        self.true_value = true_value
        self.sheet_child = sheet
        self.separate_value = separate_value
        self.replace_sheet = replace_type_name  # 要替换的sheet字典
        self.replace_flag = replace_flag  # 判断是否要替换的flag
        self.replace_file = replace_file  # 从文件file内替换

        self.dist_num = dist_num
        self.province = province
        self.site_num = site_num
        self.long = long
        self.lat = lat
        self.alt = alt

        self.select_type_year = select_type_year   # 要处理的年份
        self.select_type_month = select_type_month # 要处理的月份

        self.specil_types_value = specil   # 特殊值的处理方法
        self.specil_select = specil_select  # 已经选择要处理的特值
        tqdm.write("开始处理数据")
        star = time.time()
        # profiler = Profiler()
        # profiler.start()
        MyTxtToExcel.txtFloders(self)
        # profiler.stop()
        # profiler.print()

        if cd.csv_txt is True:
            print("处理完毕，开始文件格式转换：txt -> csv")
            for k in cd.source_modify:
                os.rename(k[1], k[0])
            cd.csv_txt = False
            cd.source_modify.clear()
        print("用时:%.2f秒,%.2f分钟" % (time.time()-star, (time.time() - star)/60))

    '''判断存放处理好的数据的文件夹是否存在'''
    def ifExist(self, file):
        if os.path.exists(file) == False:
            tqdm.write(file + "不存在,建立了一个新文件夹")
            os.makedirs(file)

    '''从文本获得信息'''
    # 获取组合气象因子的信息
    #@get_abnormal
    def getCombTxtInfo(self, file, types):

        month_day = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]  # 月份天数的数据，用于后续给每一个sheet添加表头

        dict_of_data = {}
        with open(file, 'r', encoding='utf-8') as f:
            lines = f.readlines()

        for line in lines[1:]:
            info = []
            temp = re.findall(r'[^\s]+', line) # 获取文本数据
            for x in temp:
                if self.is_number(x) is True:
                    info.append(float(x))
                else:
                    info.append(x)
            info.insert(1, '缺失')  # 插入三个缺失数据
            info.insert(2, '缺失')
            info.insert(3, '缺失')
            station, year, month, day = info[0], info[4], info[5], info[6]
            if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
                month_day[2] = 29  # 如果为闰年，则改变2月的数量
            else:
                month_day[2] = 28
            if station not in dict_of_data.keys():
                dict_of_data[station] = {}                      # 每一个区站号对应着好几个月份，每一个月份对应着各个
                if month not in dict_of_data[station].keys():  # 如果月份不在内
                    dict_of_data[station][month] = []           # 添加为列表的数据格式
                    index = 1
                    for num in range(0, month_day[month]):
                        temp = [x for x in info[0:6]]
                        temp.append(index)
                        for w in info[7:]:
                            temp.append('缺失')
                        index += 1
                        dict_of_data[station][month].append(temp)
                    dict_of_data[station][month][day - 1] = info
                else:  # 如果有了该月份，表示该数据之前添加进去了，那么就可以直接往内部添加数据
                    dict_of_data[station][month][day - 1] = info
            else:
                if month not in dict_of_data[station].keys():  # 如果存在区站号，但是月份并不存在，表示这个月份数据是夹在了连续的月份之间的。
                    if month not in dict_of_data[station].keys():  # 如果月份不在内
                        dict_of_data[station][month] = []  # 添加为列表的数据格式
                        index = 1
                        for num in range(0, month_day[month]):
                            temp = [x for x in info[0:6]]
                            temp.append(index)
                            for w in info[7:]:
                                temp.append('缺失')
                            index += 1
                            dict_of_data[station][month].append(temp)
                        dict_of_data[station][month][day - 1] = info
                    else:  # 如果有了该月份，表示该数据之前添加进去了，那么就可以直接往内部添加数据
                        dict_of_data[station][month][day - 1] = info
                else:
                    dict_of_data[station][month][day - 1] = info
        all_lines, true_value_flag_lines = {}, {}
        for s, v in dict_of_data.items():
            k = v.keys()
            break
        for month in k:
            all_lines[month] = []
            true_value_flag_lines[month] = []
        for staion, values in dict_of_data.items():
            for month, value in values.items():
                for v in value:
                    all_lines[month].append(v)

        if self.true_value_flag == '是' and len(self.specil_select) == 0:
            for month, lines in all_lines.items():
                for line in lines:
                    i = 0
                    temp_line = []
                    for temp in line:
                        if temp == '32766' or temp == '-32766':
                            temp = '缺测'
                        elif temp == '999998':
                            temp = '未估'
                        elif temp in ['32744', '-32744']:
                            temp = '空值'
                        else:
                            if self.coefficients[types][i] < 1 and temp != self.lose_value:  # 需要乘以真实值系数，这里考虑日系数
                                temp = float(temp) * float(self.true_value)
                            else:
                                if self.is_number(temp) == True:
                                    temp = int(temp)
                                else:
                                    temp = temp
                        temp_line.append(temp)
                        i += 1
                    true_value_flag_lines[month].append(temp_line)
            return true_value_flag_lines
        else:
            return all_lines

    def is_number(self, s):
        try:
            float(s)
            return True
        except ValueError:
            pass

        try:
            import unicodedata
            unicodedata.numeric(s)
            return True
        except (TypeError, ValueError):
            pass
        return False

    #@get_abnormal
    def getTxtInfo(self, file, types):
        lines, true_value_flag_lines = [], []
        not_true_value_flag = []
        with open(file, "r") as f:
            infos = f.readlines()
        for info in infos[0 if cd.csv_txt is False else 1:]:
            digi_info = re.findall(r'[^\s,]+', info)
            if '组合气象因子' in self.comb_data_file:
                digi_info.insert(1, self.lose_value)
                digi_info.insert(2, self.lose_value)
                digi_info.insert(3, self.lose_value)
            if cd.special_check is False:  # 只有当是特殊数据的时候，才需要调换经纬度的位置。如果数据不存在，则不需要交换
                digi_info[1], digi_info[2] = digi_info[2], digi_info[1]   # 调整经纬度的位置
            if digi_info.count('NaN') != 0:
                for i in range(digi_info.count('NaN')):
                    digi_info[digi_info.index('NaN')] = '-999'
            lines.append(digi_info)
        for line in lines:  # 先转换为数字
            temp = []
            for x in line:
                if self.is_number(x) is True:
                    temp.append(float(x))
                else:
                    temp.append(x)
            not_true_value_flag.append(temp)
        if self.true_value_flag == '是' and len(self.specil_select) == 0:  # 如果是需要真实值转换的，且不需要任何的特值处理的话
            for line in lines:
                i = 0
                temp_line = []
                for temp in line:
                    if temp == '32766' or temp == '-32766':
                        temp = '缺测'
                    elif temp == '999998':
                        temp = '未估'
                    elif temp in ['32744', '-32744']:
                        temp = '空值'
                    else:
                        if self.coefficients[types][i + 3 if (cd.special_check is True and i >= 1) else i] < 1 and temp != self.lose_value:  # 需要乘以真实值系数，这里考虑日系数
                            temp = float(temp) * float(self.true_value)
                        else:
                            if self.is_number(temp) is True:
                                temp = float(temp)
                            else:
                                temp = temp
                    temp_line.append(temp)
                    i += 1
                true_value_flag_lines.append(temp_line)
            # print("true_value_flag_lines:",true_value_flag_lines)
            return true_value_flag_lines
        else:
            return not_true_value_flag

    '''
        处理信息，获得数字信息
    '''
<<<<<<< HEAD
    #@get_abnormal
=======
    # @get_abnormal
>>>>>>> 93d9ef9bbb775d0c1b8c98405f600a1c4039aae8
    def dealWithTxtInfo(self, pois):  # file: CLO(云量) txt_file: SURF_CLI_CHN_MUL_MON-CLO-195101.TXT
        temp = re.findall(r'-(\w{3,6}|\d{4})', pois)
        types, year = temp[0], int(temp[-1])  # types 类型
        if '0cm' in temp or '0CM' in temp:
            types = 'GST_0CM'
        sheet_nums = len(self.name_types[types]) - 7  # sheet的数量
        wb = Workbook()  # 创建一个表格
        wb.active
        ws = wb['Sheet']  # 移除第一个Sheet，使后续的sheet为sheet1,sheet2递增方式
        wb.remove(ws)
        sheets = []
        day_sheets = []   # 处理日数据的时候所需要的临时sheet列表
        all_sheet_info = {}
        day_all_sheet_info = {}
        pois_data = {}
        for num in range(1, sheet_nums + 1):  # sheet的数量
            sheet_name = '{}'.format(self.name_types[types][6 + num])
            # print(sheet_name)
            for dele in self.sheet_child[types]:
                if dele == sheet_name:  # 若是要处理的
                    all_sheet_info[dele] = []  # sheet1, sheet2, sheet3 ...
                    day_all_sheet_info[dele] = []
                    pois_data[dele] = {}
                    ws = wb.create_sheet(sheet_name)
                    sheets.append(ws)  # 创建气象因素个数的表格数
                    day_sheets.append(ws)
        for month in self.select_type_month[types]:  # 月份
            str_month = month if month >= 10 else ('0' + str(month))
            txt_file = pois.format(str_month)  # 构造12个月的txt文件位置
            if os.path.exists(txt_file) == True:  # 如果该月份的文件存在
                bug_msg = self.judge_data_bug(txt_file)  # 在文件存在的情况下，检查文件中是否存在bug
                if len(bug_msg) == 0:
                    if "组合" in txt_file:
                        liness = MyTxtToExcel.getCombTxtInfo(self, txt_file, types)
                        for _month, lines in liness.items():
                            # print("开始处理组合气象因子数据了")
                            str_month = _month if _month >= 10 else ('0' + str(_month))
                            month_day = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]  # 月份天数的数据，用于后续给每一个sheet添加表头
                            for ws in sheets:
                                if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
                                    month_day[2] = 29  # 如果为闰年，则改变2月的数量
                                basic = ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月']
                                for num in range(1, month_day[_month] + 1):
                                    basic.append("{}日".format(num))
                                # print(basic)
                                ws.append(basic)  # 添加进sheet中去,作为表头
                            p = 0  # 插入的位置
                            flag = 1
                            for row in range(0, len(lines)):  # 一次性处理所有的数据，每一行每一行数据的处理
                                if self.true_value_flag == '是' and len(self.specil_select) != 0:
                                    if lines[row][3] != self.lose_value:
                                        lines[row][3] = lines[row][3] * 0.1  # 先处理海拔高度的小数处理
                                for num in range(0, len(wb.sheetnames)):
                                    name = wb.sheetnames[num]
                                    ture_poi_number = self.name_types[types].index(name)  # 找到真实的位置
                                    if flag == 1:
                                        temp = lines[row][:6]
                                        all_sheet_info[name].append(temp)
                                        for i in range(0, month_day[_month]):
                                            all_sheet_info[name][p].append(self.lose_value)  # 首先全部默认为丢失的数据
                                    day_value = lines[row][ture_poi_number]  # 日常数据
                                    if day_value == 32766 or day_value == -32766:
                                        day_value = '缺测'
                                    elif day_value == 999998:
                                        day_value = '未估'
                                    elif day_value == 32744 or day_value == -32744:
                                        day_value = '空值'
                                    else:
                                        if len(self.specil_select) != 0:
                                            for k in self.specil_select:  # 选择列表
                                                if types == k[0] and len(self.specil_types_value[types][k[1]]) != 0 and type(day_value) == int or type(day_value) == float:  # 如果存在处理的
                                                    day_value = self.getSpecialValue(day_value, types, name, k[1])
                                        if self.true_value_flag == '是':  # 如果要小数处理，则
                                            if len(self.specil_select) != 0 and self.coefficients[types][ture_poi_number] < 1 and day_value not in ['缺测', self.lose_value]:
                                                day_value = float(day_value) * float(
                                                    self.coefficients[types][ture_poi_number])
                                    all_sheet_info[name][p][5 + lines[row][6]] = day_value  # 把数据添加到指定的天位置
                                flag = 0
                                if row < len(lines) - 1 and lines[row][0] != lines[row + 1][0]:  # 如果上下的区站号不等了，则表示是下一项数据
                                    p += 1
                                    flag = 1
                            file_name = "{}_{}{}ok.xlsx".format(types, year, str_month)
                            MyTxtToExcel.detectLoseColumn(self, wb.sheetnames, all_sheet_info[wb.sheetnames[0]], all_sheet_info, wb)  # 某一个气象因子就可以找出缺失列
                            wb = MyTxtToExcel.infosInExcel(self, sheets, all_sheet_info, wb.sheetnames, types,wb)  # 将数据写入到excel中去
                            if self.separate_value == '否':
                                if os.path.exists(self.output + "\\" + types) == False:
                                    os.makedirs(self.output + "\\" + types)
                                print("存放到文件:{}".format(self.output + "\\" + types + "\\" + file_name))
                                wb.save(self.output + "\\" + types + "\\" + file_name)
                            else:
                                MyTxtToExcel.separateSheets(self, wb, types, year, file_name)
                            for key in all_sheet_info.keys():
                                all_sheet_info[key] = []
                            sheets.clear()  # 清除原先excel的数据
                            wb = Workbook()  # 创建一个表格
                            ws = wb['Sheet']  # 移除第一个Sheet，使后续的sheet为sheet1,sheet2递增方式
                            wb.remove(ws)
                            for key in all_sheet_info.keys():  # 重新建立sheet
                                ws = wb.create_sheet(key)
                                sheets.append(ws)
                    else:
                        lines = MyTxtToExcel.getTxtInfo(self, txt_file, types)              # 获取日文件数据
                        month_day = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]  # 月份天数的数据，用于后续给每一个sheet添加表头
                        for ws in sheets:
                            if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
                                month_day[2] = 29  # 如果为闰年，则改变2月的数量
                            basic = ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月']
                            for num in range(1, month_day[month] + 1):
                                basic.append("{}日".format(num))
                            if cd.special_check is True:
                                basic.remove('经度')  # 删除这三个不需要的数据
                                basic.remove('纬度')
                                basic.remove('观测场拔海高度')
                            ws.append(basic)  # 添加进sheet中去,作为表头
                        p = 0  # 插入的位置
                        flag = 1
                        for row in range(0, len(lines)):  # 一次性处理所有的数据，每一行每一行数据的处理
                            if self.true_value_flag == '是' and len(self.specil_select) != 0:
                                if cd.special_check is False and lines[row][3] != self.lose_value:  # 加一个限制条件，需要非特殊数据
                                    lines[row][3] = lines[row][3] * 0.1  # 先处理海拔高度的小数处理
                            for num in range(0, len(wb.sheetnames)):
                                name = wb.sheetnames[num]
                                ture_poi_number = self.name_types[types].index(name) + cd.special_length_modify  # 找到真实的位置(进行修改：若是特殊数据，需要减去3
                                if flag == 1:
                                    temp = lines[row][:6 if cd.special_check is False else 3]  # 这里修改为若不是特殊数据，则只需要获取前三个即可
                                    all_sheet_info[name].append(temp)
                                    for i in range(0, month_day[month]):
                                        all_sheet_info[name][p].append(self.lose_value)  # 首先全部默认为丢失的数据
                                day_value = lines[row][ture_poi_number]  # 日常数据
                                if day_value == 32766 or day_value == -32766:
                                    day_value = '缺测'
                                elif day_value == 999998:
                                    day_value = '未估'
                                elif day_value == 32744 or day_value == -32744:
                                    day_value = '空值'
                                else:
                                    if len(self.specil_select) != 0:
                                        for k in self.specil_select:  # 选择列表
                                            # print("self.sepcil_select2:{}, day_value:{}, types:{}, name:{}, k[1]:{}".format(self.specil_select, day_value, types, name, k[1]))
                                            if types == k[0] and len(self.specil_types_value[types][k[1]]) != 0 and type(day_value) == int or type(day_value) == float:  # 如果存在处理的
                                                day_value = self.getSpecialValue(day_value, types, name, k[1])
                                    if self.true_value_flag == '是':  # 如果要小数处理，则
                                        if cd.csv_txt is True:
                                            temp_ture_poi_number = ture_poi_number + 3
                                        else:
                                            temp_ture_poi_number = ture_poi_number
                                        if len(self.specil_select) != 0 and self.coefficients[types][temp_ture_poi_number] < 1 and day_value not in ['缺测', self.lose_value]:
                                            day_value = float(day_value) * float(self.coefficients[types][temp_ture_poi_number])
                                all_sheet_info[name][p][5 + cd.special_length_modify + int(lines[row][6+cd.special_length_modify])] = day_value  # 把数据添加到指定的天位置
                            flag = 0
                            if row < len(lines) - 1 and lines[row][0] != lines[row + 1][0]:  # 如果上下的区站号不等了，则表示是下一项数据
                                p += 1
                                flag = 1
                        file_name = "{}_{}{}ok.xlsx".format(types, year, str_month)
                        MyTxtToExcel.detectLoseColumn(self, wb.sheetnames, all_sheet_info[wb.sheetnames[0]], all_sheet_info, wb)  # 某一个气象因子就可以找出缺失列
                        wb = MyTxtToExcel.infosInExcel(self, sheets, all_sheet_info, wb.sheetnames, types, wb)  # 将数据写入到excel中去
                        if self.separate_value == '否':
                            if os.path.exists(self.output + "\\" + types) == False:
                                os.makedirs(self.output + "\\" + types)
                            print("存放到文件:{}".format(self.output + "\\" + types + "\\" + file_name))
                            wb.save(self.output + "\\" + types + "\\" + file_name)
                        else:
                            MyTxtToExcel.separateSheets(self, wb, types, year, file_name)
                        for key in all_sheet_info.keys():
                            all_sheet_info[key] = []
                        sheets.clear()  # 清除原先excel的数据
                        wb = Workbook()  # 创建一个表格
                        ws = wb['Sheet']  # 移除第一个Sheet，使后续的sheet为sheet1,sheet2递增方式
                        wb.remove(ws)
                        for key in all_sheet_info.keys():  # 重新建立sheet
                            ws = wb.create_sheet(key)
                            sheets.append(ws)
                else:
<<<<<<< HEAD
                    print("文件{}有错，错误信息:{}".format(txt_file, bug_msg[0]))
=======
                    print("文件{}有错，错误信息列表:{}".format(txt_file, bug_msg[0]))
>>>>>>> 93d9ef9bbb775d0c1b8c98405f600a1c4039aae8

    #@get_abnormal
    def dealWithLines(self, sheets, year, month, wb, lines, types, all_sheet_info, str_month):
        month_day = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]  # 月份天数的数据，用于后续给每一个sheet添加表头
        for ws in sheets:
            if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
                month_day[2] = 29  # 如果为闰年，则改变2月的数量
            basic = ['区站号', '经度', '纬度', '观测场拔海高度', '年', '月']
            for num in range(1, month_day[month] + 1):
                basic.append("{}日".format(num))
            ws.append(basic)  # 添加进sheet中去,作为表头
        p = 0  # 插入的位置
        flag = 1
        for row in range(0, len(lines)):  # 一次性处理所有的数据，每一行每一行数据的处理
            if self.true_value_flag == '是' and len(self.specil_select) != 0:
                if lines[row][3] != self.lose_value:
                    lines[row][3] = lines[row][3] * 0.1  # 先处理海拔高度的小数处理
            for num in range(0, len(wb.sheetnames)):
                name = wb.sheetnames[num]
                ture_poi_number = self.name_types[types].index(name)  # 找到真实的位置
                if flag == 1:
                    temp = lines[row][:6]
                    all_sheet_info[name].append(temp)
                    for i in range(0, month_day[month]):
                        all_sheet_info[name][p].append(self.lose_value)  # 首先全部默认为丢失的数据
                day_value = lines[row][ture_poi_number]  # 日常数据
                if day_value == 32766 or day_value == -32766:
                    day_value = '缺测'
                elif day_value == 999998:
                    day_value = '未估'
                elif day_value == 32744 or day_value == -32744:
                    day_value = '空值'
                else:
                    if len(self.specil_select) != 0:
                        for k in self.specil_select:  # 选择列表
                            if types == k[0] and len(self.specil_types_value[types][k[1]]) != 0 and type(day_value) == int or type(day_value) == float:  # 如果存在处理的
                                day_value = self.getSpecialValue(day_value, types, name, k[1])
                    if self.true_value_flag == '是':  # 如果要小数处理，则
                        if len(self.specil_select) != 0 and self.coefficients[types][ture_poi_number] < 1 and day_value not in ['缺测', self.lose_value]:
                            day_value = float(day_value) * float(self.coefficients[types][ture_poi_number])
                all_sheet_info[name][p][5 + lines[row][6]] = day_value  # 把数据添加到指定的天位置
            flag = 0
            if row < len(lines) - 1 and lines[row][0] != lines[row + 1][0]:  # 如果上下的区站号不等了，则表示是下一项数据
                p += 1
                flag = 1
        file_name = "{}_{}{}ok.xlsx".format(types, year, str_month)
        MyTxtToExcel.detectLoseColumn(self, wb.sheetnames, all_sheet_info[wb.sheetnames[0]], all_sheet_info, wb)  # 某一个气象因子就可以找出缺失列
        wb = MyTxtToExcel.infosInExcel(self, sheets, all_sheet_info, wb.sheetnames, types, wb)  # 将数据写入到excel中去
        if self.separate_value == '否':
            if os.path.exists(self.output + "\\" + types) == False:
                os.makedirs(self.output + "\\" + types)
            print("存放到文件:{}".format(self.output + "\\" + types + "\\" + file_name))
            wb.save(self.output + "\\" + types + "\\" + file_name)
        else:
            MyTxtToExcel.separateSheets(self, wb, types, year, file_name)
        for key in all_sheet_info.keys():
            all_sheet_info[key] = []
        sheets.clear()  # 清除原先excel的数据
        wb = Workbook()  # 创建一个表格
        ws = wb['Sheet']  # 移除第一个Sheet，使后续的sheet为sheet1,sheet2递增方式
        wb.remove(ws)
        for key in all_sheet_info.keys():  # 重新建立sheet
            ws = wb.create_sheet(key)
            sheets.append(ws)

    #@get_abnormal
    def detectLoseColumn(self, sheetnames, one_of_infos, all_sheet_info, wb):
        lose_column = []
        for i in range(len(one_of_infos[0])):
            lose_column.append(1)  # 一开始都设为1， 0表示不是该列
        for first_value in one_of_infos:
            for pois in range(0, len(first_value)):  # 内部对每一行数据进行循环判断
                if lose_column[pois] == 1:  # 如果该行数据不是缺失数据
                    if first_value[pois] != self.lose_value:
                        lose_column[pois] = 0
        if 1 in lose_column:        # 如果存在某一列的缺失值
            for i in range(lose_column.count(1)):
                for name in sheetnames:
                    pois = lose_column.index(1)
                    for first_value in all_sheet_info[name]:
                        del first_value[pois]
                    wb[name].delete_cols(pois+1)  # 明天： 直接重新定位第一个
                lose_column[pois] = 0
                for k in range(1):   # 循环向左移动一个
                    lose_column.insert(len(lose_column), lose_column[0])
                    lose_column.remove(lose_column[0])

    #@get_abnormal
    def getSpecialValue(self, day_value, types, name, flag):
        if day_value == 32766 or day_value == -32766:
            return '缺测'
        elif day_value == 32744 or day_value == -32744:
            day_value = '空值'
        if types == 'PRS' and (name == '日最高本站气压' or name == '日最低本站气压'):  # 如果是处理气压的气象因素 0设为0 1提取XXX 2为提取出原值
            if day_value >= 20000 and flag == '+20000(气压极值取自定值时,在原值上加20000)' :  # 如果大于20000并且是要处理的，则设定为0，否则不做处理
                if self.specil_types_value[types]['+20000(气压极值取自定值时,在原值上加20000)'][-1] == 0:
                    day_value = 0
                elif self.specil_types_value[types]['+20000(气压极值取自定值时,在原值上加20000)'][-1] == 2:
                    day_value = day_value - 20000
        elif types == 'RHU' and name == '最小相对湿度(仅自己)':  # 湿度的情况
            if day_value >= 300 and flag == '+300(最小相对湿度取自定值时,在原值上+300)':
                if self.specil_types_value[types]['+300(最小相对湿度取自定值时,在原值上+300)'][-1] == 0:
                    day_value = 0
                elif self.specil_types_value[types]['+300(最小相对湿度取自定值时,在原值上+300)'][-1] == 2:
                    day_value -= 300
        elif types == 'WIN':
            if name in ['平均风速', '最大风速', '极大风速']:  # 处理风速的特征值
                if day_value >= 1000 and flag == '+1000(当风速超过仪器测量上限时,在上限数据基础上加1000)' :
                    if self.specil_types_value[types]['+1000(当风速超过仪器测量上限时,在上限数据基础上加1000)'][-1] == 0:
                        day_value = 0
                    elif self.specil_types_value[types]['+1000(当风速超过仪器测量上限时,在上限数据基础上加1000)'][-1] == 2:
                        day_value -= 1000
            elif name in ['最大风速的风向', '极大风速的风向']:
                if day_value >= 100 and flag == '+100(当表示风向为八风向时,在原值上加100)' :
                    if self.specil_types_value[types]['+100(当表示风向为八风向时,在原值上加100)'][-1] == 0:
                        day_value = 0
                    elif self.specil_types_value[types]['+100(当表示风向为八风向时,在原值上加100)'][-1] == 2:
                        day_value -= 100
<<<<<<< HEAD
                elif '90' in str(day_value) and float(day_value) >= 900 and flag == '90X(风向出现X个时,风向数据个数用X表示)' and self.specil_types_value[types]['90X(风向出现X个时,风向数据个数用X表示)'][-1] == 1:  # 如果要提取X并且该数据是90X
                    day_value = int(str(day_value)[-1:])  # 提取X
                elif '95' in str(day_value) and float(day_value) >= 950 and flag == '95X(风向至少出现X个时,风向数据用个数X表示)' and self.specil_types_value[types]['95X(风向至少出现X个时,风向数据用个数X表示)'][-1] == 1 :  # 如果该数据是95X且要提取X
                    day_value = int(str(day_value)[-1:])  # 提取X
        elif types == 'PRE':
            if day_value == 32700 and flag == '32700(表示降水"微量")' and self.specil_types_value[types]['32700(表示降水"微量")'][-1] == 0:
                day_value = 0
            elif '32' in str(day_value) and float(day_value) >= 32000 and day_value != 32700:
                if flag == '32XXX(XXX为纯雾露霜)' and self.specil_types_value[types]['32XXX(XXX为纯雾露霜)'][-1] == 1 :  # 如果是要提取XXX
                    day_value = int(str(day_value)[-3:])
                elif flag == '32XXX(XXX为纯雾露霜)' and self.specil_types_value[types]['32XXX(XXX为纯雾露霜)'][-1] == 0 :
=======
                elif '90' in str(day_value) and flag == '90X(风向出现X个时,风向数据个数用X表示)' and float(day_value) >= 900 and self.specil_types_value[types]['90X(风向出现X个时,风向数据个数用X表示)'][-1] == 1:  # 如果要提取X并且该数据是90X
                    day_value = float(str(day_value)[-1:])  # 提取X
                elif '95' in str(day_value) and flag == '95X(风向至少出现X个时,风向数据用个数X表示)' and float(day_value) >= 950 and self.specil_types_value[types]['95X(风向至少出现X个时,风向数据用个数X表示)'][-1] == 1 :  # 如果该数据是95X且要提取X
                    day_value = float(str(day_value)[-1:])  # 提取X
        elif types == 'PRE':
            if day_value == 32700 and flag == '32700(表示降水"微量")' and self.specil_types_value[types]['32700(表示降水"微量")'][-1] == 0:
                day_value = 0
            elif '32' in str(day_value) and day_value != 32700 and float(day_value) >= 32000:
                if flag == '32XXX(XXX为纯雾露霜)' and self.specil_types_value[types]['32XXX(XXX为纯雾露霜)'][-1] == 1 :  # 如果是要提取XXX
                    day_value = float(str(day_value)[-3:])
                elif flag == '32XXX(XXX为纯雾露霜)'  and self.specil_types_value[types]['32XXX(XXX为纯雾露霜)'][-1] == 0 :
>>>>>>> 9b988744b9094e235d0206c22ab1011802914ecc
                    day_value = 0
            elif '31' in str(day_value) and float(day_value) >= 31000:
                if flag == '31XXX(XXX为雨和雪的总量)' and self.specil_types_value[types]['31XXX(XXX为雨和雪的总量)'][-1] == 1 :  # 如果是要提取XXX
                    day_value = float(str(day_value)[-3:])
                elif flag == '31XXX(XXX为雨和雪的总量)' and self.specil_types_value[types]['31XXX(XXX为雨和雪的总量)'][-1] == 0:
                    day_value = 0
            elif '30' in str(day_value) and float(day_value) >= 30000:
                if flag == '30XXX(XXX为雪量(仅包括雨夹雪,雪暴))' and self.specil_types_value[types]['30XXX(XXX为雪量(仅包括雨夹雪,雪暴))'][-1] == 1 :  # 如果是要提取XXX
                    day_value = float(str(day_value)[-3:])
                elif flag == '30XXX(XXX为雪量(仅包括雨夹雪,雪暴))' and self.specil_types_value[types]['30XXX(XXX为雪量(仅包括雨夹雪,雪暴))'][-1] == 0:
                    day_value = 0
        elif types == 'EVP' and flag == '30XXX(XXX为雪量(仅包括雨夹雪,雪暴))' and self.specil_types_value[types]['+1000(蒸发器中注入的水全部蒸发,在注入的水量数据基础上加1000)'][-1] == 0:
            day_value = 0
        elif types == 'GST' or types == 'GST_0CM':
            if flag == '+10000(实际温度(零上)超仪器上限刻度,在上限数据基础上加10000)' and day_value >= 10000 :
                if self.specil_types_value[types]['+10000(实际温度(零上)超仪器上限刻度,在上限数据基础上加10000)'][-1] == 0:
                    day_value = 0
                elif self.specil_types_value[types]['+10000(实际温度(零上)超仪器上限刻度,在上限数据基础上加10000)'][-1] == 2:
                    day_value -= 10000
            elif flag == '-10000(实际温度(零下)超仪器上限刻度,在上限数据基础上减10000)' and day_value <= -10000:
                if self.specil_types_value[types]['-10000(实际温度(零下)超仪器上限刻度,在上限数据基础上减10000)'][-1] == 0:
                    day_value = 0
                elif self.specil_types_value[types]['-10000(实际温度(零下)超仪器上限刻度,在上限数据基础上减10000)'][-1] == 2:
                    day_value += 10000
        elif types == '组合气象因子':
            if name in ['日最高本站气压', '日最低本站气压']:
                if day_value >= 20000 and flag == '+20000(气压极值取自定值时,在原值上加20000)':  # 如果大于20000并且是要处理的，则设定为0，否则不做处理
                    if self.specil_types_value[types]['+20000(气压极值取自定值时,在原值上加20000)'][-1] == 0:
                        day_value = 0
                    elif self.specil_types_value[types]['+20000(气压极值取自定值时,在原值上加20000)'][-1] == 2:
                        day_value = day_value - 20000
            if name == '20-20时降水量':
                if day_value == 32700 and flag == '32700(表示降水"微量")' and self.specil_types_value[types]['32700(表示降水"微量")'][-1] == 0:
                    day_value = 0
        return day_value

    #@get_abnormal
    def separateSheets(self, wb, types, year, file_name):
        for name in wb.sheetnames:  # name 表示某一个气象因子
            ws = wb[name]
            ws.freeze_panes = 'A2'   # 分隔开后也要冻结窗口
            floder = self.output + "\\" + name  # 直接在输出所在的文件夹内新建一个文件
            if os.path.exists(floder) == False:
                os.makedirs(floder)  # 创立文件夹
            wb_temp = Workbook()
            wb_temp.remove(wb_temp['Sheet'])  # 移除掉第一个
            ws_temp = wb_temp.create_sheet(name)  # 创立一个新的
            for i, row in enumerate(ws.iter_rows()):
                for k, cell in enumerate(row):
                    ws_temp.cell(row=i + 1, column=k + 1, value=cell.value)
            wb_temp.save(floder + "\\" + file_name)

    #@get_abnormal
    def infosInExcel(self, sheets, all_sheet_info, sheetnames, types, wb):  # type 类型
        new_wb = wb
        i = 0
        for ws in sheets:
            ws.freeze_panes = 'A2'   # 冻结第一行
            for info in all_sheet_info['{}'.format(sheetnames[i])]:  # 保存信息
                ws.append(info)
            i += 1
        # print("删除对应的列")
        '''删除对应的列'''
        max_col = None
        for ws in sheets:
            if max_col is None:
                max_col = ws.max_column
            if len(self.sheet_child[types]) != 0:
                list_type = self.name_types[types]  # 为一个列表,标准的，写入到excel的列表顺序
                # print(list_type, self.sheet_child[types])
                for i in range(len(list_type)):
                    if list_type[i] not in self.sheet_child[types]:  # 找到不在列表中的元素
                        for k in range(65, 65 + max_col):  # 从A --- Z开始寻找
                            if chr(k) > 'Z':
                                e = ['0', 'A', 'B', 'C']
                                letter = e[int((k-65)/26)]+chr(k-26*int((k-65)/26))
                            else:
                                letter = chr(k)
                            if list_type[i] == ws["{}1".format(letter)].value:  # 寻找该元素在excel中的位置
                                ws.delete_cols(k - 65 + 1)  # 删除对应的列, +1处理是因为在excel中，从1开始计数
        if self.replace_flag == "是":
            new_wb = self.repalceInfo(sheets, self.replace_file, types, self.dist_num, self.province, self.site_num, self.long, self.lat, self.alt)
            # profiler.stop()
            # profiler.print()
        return new_wb # 如果是新的需要替换的，则将优化后的wb返回出去

    '''
        替换excel内的数据操作
        sheets：要替换的数据的列表
        file：替换的数据所在地
        types，替换的气象类型
        dist_num, province, site_num, long, lat, alt_m: 区站号，省份，站名，经度，纬度，海拔。
    '''
    # @print_run_time
    def repalceInfo(self, sheets, file, types, dist_num, province, site_num, long, lat, alt_m):
        letter, num_letter = {}, {}
        ws = sheets[0]
        for k in range(65, 65 + ws.max_column + 8):
            e = ['0', 'A', 'B', 'C']
            letter[k - 64] = e[int((k - 65) / 26)] + chr(k - 26 * int((k - 65) / 26)) if chr(k) > 'Z' else chr(k)

        for k in range(65, 65 + ws.max_column + 8):
            e = ['0', 'A', 'B', 'C']
            let = e[int((k - 65) / 26)] + chr(k - 26 * int((k - 65) / 26)) if chr(k) > 'Z' else chr(k)
            num_letter[let] = k - 64
        repalce_wb = load_workbook(file)  # 替换的值所在的列表数据
        repalce_ws = repalce_wb[repalce_wb.sheetnames[0]]
        list_replace_station = []
        base_row = [x.value for x in repalce_ws['A1:{}1'.format(letter[repalce_ws.max_column])][0]]  # 获得表头一行的值
        if base_row.count("long") > 0:  # 如果是含有long的
            dist_num, province, site_num, rep_long, rep_lat, rep_alt = letter[base_row.index("区站号") + 1], letter[base_row.index("省份") + 1], letter[base_row.index("站名") + 1], base_row.index('long') + 1, base_row.index('lat') + 1, base_row.index('测站ALT_m') + 1
        elif base_row.count("经度") > 0:  # 如果是含有经度的中文的
            dist_num, province, site_num, rep_long, rep_lat, rep_alt = letter[base_row.index("区站号") + 1], letter[base_row.index("省份") + 1], letter[base_row.index("站名") + 1], base_row.index('经度') + 1, base_row.index('纬度') + 1, base_row.index('海拔') + 1
        else:  # 其他的就是用户指定，表明表头不存在，全为数字
            rep_long, rep_lat, rep_alt = num_letter[long], num_letter[lat], num_letter[alt_m]  # 直接指定的位置，按照ABC的方式来

        if base_row.count("long") > 0 or base_row.count("经度") > 0:  # 如果第一列有long 或者 经度关键字，可以判定第一行是存在表头的
            for i in range(2, repalce_ws.max_row + 1):
                num = str(repalce_ws['{}'.format(dist_num) + str(i)].value)
                if self.is_number(num) is True:
                    num = int(num)
                list_replace_station.append(num)  # 将区站号的值加入进去
        else:
            for i in range(1, repalce_ws.max_row + 1):
                num = str(repalce_ws['{}'.format(dist_num) + str(i)].value)
                if self.is_number(num) is True:
                    num = int(num)
                list_replace_station.append(num)  # 将区站号的值加入进去
        list_AZ = get_column_interval(1, 20)
        # print(list_AZ)
        max_r = None
        for ws in sheets:  # 一个一个sheet来处理
            if max_r is None:
                max_r = ws.max_row
            if self.replace_sheet[types][ws.title] == "替换":  # 如果该气象因子选择了要替换
                ws.move_range("B1:{}{}".format(letter[ws.max_column], max_r), cols=5)  # 向右侧移动5个，分给要加入的数据
                ws["B1"] = '省份'
                ws['C1'] = '站名'
                ws['D1'] = '经度'
                ws['E1'] = '纬度'
                ws['F1'] = '观测场拔海高度'
                base_row = [x.value for x in ws['A1:{}1'.format(letter[ws.max_column])][0]]  # 这一行的数据是要替换的ws的表头，一定存在
                long, lat, alt_m = 0, 0, 0
                if '经度' in base_row:  # 寻找经度纬度海拔三个位置
                    long = base_row.index('经度') + 1
                if '纬度' in base_row:
                    lat = base_row.index('纬度') + 1
                if '观测场拔海高度' in base_row:
                    alt_m = base_row.index('观测场拔海高度') + 1
<<<<<<< HEAD
                k = []  # 替换数据用的，存在数据的部分
                for irow in range(2, ws.max_row + 1):  # 从第2行开始
                    wb_station = ws["A" + str(irow)].value
                    if wb_station in list_replace_station:  # 如果要替换的excel文件中，区站号在所要替换的excel中存在
                        k.append(irow)
                        rep_poi = list_replace_station.index(wb_station) + 2
                        ws['B' + str(irow)].value = repalce_ws['{}'.format(province) + str(rep_poi)].value  # 省份
                        ws['C' + str(irow)].value = repalce_ws['{}'.format(site_num) + str(rep_poi)].value  # 站名
                        if long > 0:  # 替换long，lat，alt的值
                            ws[letter[long] + str(irow)].value = repalce_ws[letter[rep_long] + str(rep_poi)].value
                        if lat > 0:
                            ws[letter[lat] + str(irow)].value = repalce_ws[letter[rep_lat] + str(rep_poi)].value
                        if alt_m > 0:
                            ws[letter[alt_m] + str(irow)].value = repalce_ws[letter[rep_alt] + str(rep_poi)].value
=======
                flag = 1
                k = []  # 替换数据用的，存在数据的部分
                t = 2
                for irow in ws.rows:  # 从第2行开始, 以 ws.rows的方式会更快
                    if flag == 1:
                        flag = 2
                    else:
                        wb_station = irow[0].value
                        if wb_station in list_replace_station:  # 如果要替换的excel文件中，区站号在所要替换的excel中存在
                            k.append(t)
                            rep_poi = list_replace_station.index(wb_station) + 2
                            irow[1].value = repalce_ws['{}'.format(province) + str(rep_poi)].value  # 省份
                            irow[2].value = repalce_ws['{}'.format(site_num) + str(rep_poi)].value  # 站名
                            if long > 0:  # 替换long，lat，alt的值
                                irow[list_AZ.index(letter[long])].value = repalce_ws[letter[rep_long] + str(rep_poi)].value
                            if lat > 0:
                                irow[list_AZ.index(letter[lat])].value = repalce_ws[letter[rep_lat] + str(rep_poi)].value
                            if alt_m > 0:
                                irow[list_AZ.index(letter[alt_m])].value = repalce_ws[letter[rep_alt] + str(rep_poi)].value
                        t += 1
>>>>>>> 9b988744b9094e235d0206c22ab1011802914ecc
        hava_data_pois = [1, ] + k
        wb = Workbook()
        ws = wb['Sheet']
        wb.remove(ws)
        new_sheets = []
        for sheet in sheets:  # 重新建立sheet
            ws = wb.create_sheet(sheet.title)
            new_sheets.append(ws)  # 建立一个新的sheets数据
        index = 0
<<<<<<< HEAD
=======
        temp = []
>>>>>>> 9b988744b9094e235d0206c22ab1011802914ecc
        max_col = None
        for ws in sheets:
            if max_col is None:
                max_col = ws.max_column
<<<<<<< HEAD
            for pois in hava_data_pois:
                temp = []
=======
            for pois in hava_data_pois:  # 存在数据的位置, 例如1 589 这些存在数据的位置，现在是要将该数据从原始的文件中摘取出来
>>>>>>> 9b988744b9094e235d0206c22ab1011802914ecc
                for row in range(1, max_col + 1):
                    temp.append(ws[letter[row] + str(pois)].value)
                new_sheets[index].append(temp)
                temp.clear()
            index += 1
        return wb

    #@get_abnormal
    def deleterows(self, sheet, row_num):
        max_col = sheet.max_column
        for row in range(row_num, sheet.max_row):
            for column in range(max_col):
                sheet[row][column].value = sheet[row + 1][column].value
        for cell in list(sheet.rows)[sheet.max_row - 1]:
            cell.value = None

    #@get_abnormal
    def check(self, all_sheet_info, station_number, pois):  # 检查在sheet表中是否存在
        i = 0
        for num_list in all_sheet_info[pois]:  # 在列表中寻找是否存在
            if station_number in num_list:
                return i
            i += 1
        return -1  # 如果不在的话，则插入到最后

    '''
        从txt文件夹内获取txt内的数据，存放进入一个list内
    '''

    #@get_abnormal
    def getInfo(self, file):  # file : F:\数据集\TEM（气温）
        position = []  # 文件的位置
        for txt_file in os.listdir(file):
            temp = file + "\\" + txt_file[:-6] + "{}.TXT"   # SURF_CLI_CHN_MUL_MON-CLO-{195101}.TXT
            if cd.special_check is True:  # 如果是
                if 'csv' in txt_file or 'CSV' in txt_file:
                    if cd.csv_txt is False:
                        print("文件格式转换：csv -> txt")
                        cd.csv_txt = True
                    source = file + "\\" + txt_file
                    change = source[:-3] + "TXT"
                    os.rename(source, change)
                    cd.source_modify.append([source, change])
            position.append(temp)
        position = list(set(position))  # 一个文件夹内所有的CLO文件
        for pro in tqdm(position):
            # print(pro)
            t = re.findall(r'-(\w{3,6}|[0-9]{4})', pro)
            if t[0] == 'QRA':
                types, year = t[0], t[1]
            else:
                types, year = t[0], t[-1]
            if '0cm' in t or '0CM' in t:  # 针对是GST 0cm的情况的数据
                types, year = 'GST_0CM', t[-1]
            if int(year) in self.select_type_year[types]:   # 只处理选中的年份的数据
                tqdm.write("正在处理{}-{}".format(types, year))
                MyTxtToExcel.dealWithTxtInfo(self, pro)

    #@get_abnormal
    def judge_data_bug(self, file):  # 判断即将要处理的文件是否存在bug
        '''寻找日数是否有超过该文件对应月数天数的限制'''
        month_day = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        match = re.findall(r'(\d{4})(\d{2})', os.path.basename(file))[0]
        year, month = int(match[0]), int(match[1])
        if ((int(year) % 4 == 0 and int(year) % 100 != 0) or (int(year) % 400 == 0)):
            month_day[2] = 29  # 赋值为29日
        f = open(file, encoding='utf-8')
        data = f.readlines()
        file = os.path.basename(file)
        if '0cm' in file or '0CM' in file:  # 若0cm在文件名中，则一定为GST_0CM
            t = 'GST_0CM'
        else:
            for name in cd.day_factors:
                if name in file: # 以文件名字作为标准
                    t = name
                    break
<<<<<<< HEAD
        index = self.sheet_child[t].index('处理')
        max_len = index - 2 + 1  # 数据长度
        # if cd.special_check is True:
        #     max_len -= 3
        #     for i in self.name_types[t]:
        #         if '控制码' in i:  # 统计控制码的数量
        #             max_len -= 1
=======
<<<<<<< HEAD
        index = self.sheet_child[t].index('处理')  # 处理肯定在其中
        max_len = index - 2 + 1  # 数据长度, -2是因为要处理两个添加的”处理“ ”不处理“， +1是因为缺少了日
        # print(self.sheet_child[t])
        for d in data:
            line = re.findall(r'[^\s]+', d)
            day = int(line[6])
            if day > month_day[month] or len(line) < max_len:  # 若有day的数据大于该月份的值 或者 数据长度缺失，则表示该份文件出错
                return ["文件数据有误：日数据超过了月份最大数据 或者 文件内缺失了某些气象因素数据"]
        return []
=======
        max_len = len(self.name_types[t])  # 数据长度
        if cd.special_check is True:
            max_len -= 3
            for i in self.name_types[t]:
                if '控制码' in i:  # 统计控制码的数量
                    max_len -= 1
        bug_msg = []
>>>>>>> 93d9ef9bbb775d0c1b8c98405f600a1c4039aae8
        for d in data[0 if cd.csv_txt is False else 1:]:
            line = re.findall(r'[^\s,]+', d)
            if cd.special_check is True:
                day = int(line[3])
                if day > month_day[month] or len(line) < max_len:  # 若有day的数据大于该月份的值 或者 数据长度缺失，则表示该份文件出错
                    return ["文件数据有误：日数据超过了月份最大数据 或者 文件内缺失了某些气象因素数据"]
            else:
                day = int(line[6])
                if day > month_day[month] or len(line) < max_len:  # 若有day的数据大于该月份的值 或者 数据长度缺失，则表示该份文件出错
<<<<<<< HEAD
                    return ["文件数据有误：日数据超过了月份最大数据 或者 文件内缺失了某些气象因素数据"]
        return []
=======
                    bug_msg.append(line)
        return bug_msg
>>>>>>> 9b988744b9094e235d0206c22ab1011802914ecc
>>>>>>> 93d9ef9bbb775d0c1b8c98405f600a1c4039aae8

    '''
        存放txt数据的文件夹
    '''
    #@get_abnormal
    def txtFloders(self):
        MyTxtToExcel.ifExist(self, self.output)
        floders = os.listdir(self.data_file)  # 获取子目录文件下的所有文件
        # print(floders)
        temp = floders[0]                     # 获取第一个看看是否为次级文件夹
        ss = ""
        if 'TXT' in temp or 'txt' in temp or 'csv' in temp or 'CSV' in temp:  # 如果是次级文件
            floders.clear()
            floders.append(re.findall(r'[^\\]+', self.data_file)[-1])
            for x in re.findall(r'[^\\]+', self.data_file)[:-1]:
                ss += x + "\\"
            self.data_file = ss
<<<<<<< HEAD
        # print("data_file:{} -{}".format(self.data_file, floders))
        for floder in floders:
            if 'TXT' in temp or 'txt' in temp:
                name = re.findall(r'-(\w+)', temp)[0]
            else:
                name = re.findall("\w{3,6}", floder)[0]
=======
        for floder in floders:   # 这里的floders不是为txt，就是为PRE、TMP等气象因子
            if 'TXT' in temp or 'txt' in temp or 'csv' in temp or 'CSV' in temp:
                name = re.findall(r'-(\w+)', temp)[0]
            else:
                name = re.findall("\w{3,6}", floder)[0]   # 获取当前文件下的所有数据
>>>>>>> 9b988744b9094e235d0206c22ab1011802914ecc
            if '0CM' in floder or '0cm' in floder:
                name = 'GST_0CM'
            if "处理" in self.sheet_child[name]:
                MyTxtToExcel.getInfo(self, self.data_file + "\\" + floder)  #
        tqdm.write("处理完毕")
